Systems and methods for expediting rule-based data processing

ABSTRACT

A system includes one or more memory devices storing instructions, and one or more processors configured to execute the instructions to perform steps of a method for generating a data tree structure for expediting rule-based decision-making. The system may receive a rules file having a plurality of rules, where each rule has one or more conditions and one or more actions. The system may generate a plurality of condition frequency counts that represent the total number of rules having a condition of a particular unique condition type. The system may then generate a tree structure based on the plurality of rules and the plurality of condition frequency counts, where the tree structure includes a root node and one or more node branches, where each node branch includes a first-level node and zero or more second-level nodes that each include a node condition and zero or more node actions.

This application is a continuation of, and claims priority under 35U.S.C. § 120 to, U.S. patent application Ser. No. 15/693,994, filed Sep.1, 2017, the entire contents of which is fully incorporated herein byreference.

FIELD OF INVENTION

The present disclosure relates to systems and methods for expeditingrule-based data processing, and more particularly providing systems andmethods for expediting rule-based decision-making utilizing a data treestructure.

BACKGROUND

Companies often make business decisions in accordance with a set ofever-changing rules that are created by employees of the company overtime. For example, decisions relating to whether or not to approve acustomer for a car loan and what the terms of the loan should be mayturn on a variety of different factors such as the customer's income,net worth, credit score, available down payment, value of car, amount ofthe loan, type of loan being sought, and other such considerations andthe company may have established a set of rules to help make suchdecisions. One exemplary rule might be, if a customer's credit score isbelow 500, then a minimum down payment of 20% is required. When acustomer submits a loan application form, the rules may be applied tothe customer's data to make determinations about whether to approve theloan and what the terms should be.

In order to implement an automated system of rules processing, it isdesirable to store the rules in a file that is independent from therules-processing engine so that changes to the rules can be made withouthaving the redeploy the code. Further, storing the rules in a separatefile may allow employees to easily access and modify the rules in aformat that does not require any sophisticated programming knowledge.However, in some cases, organizations may have rules models that includea large number (e.g., millions) of rules which can cause the rulesengine to take an undesirably long amount of time to load and process.Further, this process can monopolize a company's resources by requiringa lot of memory to execute.

Accordingly, there is a need for improved systems and methods to providea rule-based processing engine or device that can process a large numberof rules and input requests to generate decisions in a fashion thatproduces faster results and utilizes less memory. Embodiments of thepresent disclosure are directed to this and other considerations.

SUMMARY

Disclosed embodiments provide systems and methods for expeditingrule-based decision-making utilizing a data tree structure.

Consistent with the disclosed embodiments, the system may include one ormore memory devices storing instructions, and one or more processorsconfigured to execute the instructions to perform steps of a method ofgenerating a data tree structure for expediting rule-baseddecision-making. The system may execute the instructions to receive arules file comprising a plurality of rules, where each rule of theplurality of rules includes one or more conditions and one or moreactions and each condition is associated with a condition type. Thesystem may generate a plurality of condition frequency counts inresponse to reading the rules file. Each of the plurality of conditioncounts may be associated with a unique condition type and each conditionfrequency count may represent the total number of rules having acondition associated with the respective unique condition type. Thesystem may generate a tree structure based on the plurality of rules andthe plurality of condition frequency counts. The tree structure mayinclude a root node and one or more node branches, where each nodebranch includes a first-level node and zero of more second-level nodes,and each of the first-level nodes and the zero or more second-levelnodes include a node condition and zero or more node actions.

Consistent with the disclosed embodiments, methods and computer-readablemedia for expediting rule-based decision-making utilizing a data treestructure are also disclosed.

Further features of the disclosed design, and the advantages offeredthereby, are explained in greater detail hereinafter with reference tospecific embodiments illustrated in the accompanying drawings, whereinlike elements are indicated be like reference designators.

BRIEF DESCRIPTION OF THE DRAWINGS

Reference will now be made to the accompanying drawings, which are notnecessarily drawn to scale, and which are incorporated into andconstitute a portion of this disclosure, illustrate variousimplementations and aspects of the disclosed technology and, togetherwith the description, serve to explain the principles of the disclosedtechnology. In the drawings:

FIG. 1 is a diagram of an exemplary system for expediting rule-baseddata processing;

FIG. 2 is a component diagram of an exemplary rules processing device;

FIG. 3 is an exemplary rules file for use by a system for expeditingrule-based data processing;

FIG. 4 is an exemplary tree structure generated by a system forexpediting rule-based data processing;

FIG. 5 is a flowchart of an exemplary system for expediting rule-baseddata processing;

FIG. 6 is a flowchart of an exemplary system for generating a treestructure based on a plurality of rules and a plurality of conditionfrequency counts; and

FIG. 7 is a flowchart of another exemplary system for generating a treestructure based on a plurality of rules and a plurality of conditionfrequency counts.

DETAILED DESCRIPTION

Some implementations of the disclosed technology will be described morefully with reference to the accompanying drawings. This disclosedtechnology may, however, be embodied in many different forms and shouldnot be construed as limited to the implementations set forth herein. Thecomponents described hereinafter as making up various elements of thedisclosed technology are intended to be illustrative and notrestrictive. Many suitable components that would perform the same orsimilar functions as components described herein are intended to beembraced within the scope of the disclosed electronic devices andmethods. Such other components not described herein may include, but arenot limited to, for example, components developed after development ofthe disclosed technology.

It is also to be understood that the mention of one or more method stepsdoes not preclude the presence of additional method steps or interveningmethod steps between those steps expressly identified. Similarly, it isalso to be understood that the mention of one or more components in adevice or system does not preclude the presence of additional componentsor intervening components between those components expressly identified.

The disclosed embodiments are directed to systems and methods forgenerating a data tree structure for expediting rule-baseddecision-making. The system may include one or more memory devicesstoring instructions, and one or more processors configured to executethe instructions to perform steps of a method. Specifically, in someembodiments, the system may execute the instructions to a rules filecomprising a plurality of rules, where each rule of the plurality ofrules includes one or more conditions and one or more actions and eachcondition is associated with a condition type. The system may generate aplurality of condition frequency counts in response to reading the rulesfile. Each of the plurality of condition counts may be associated with aunique condition type and each condition frequency count may representthe total number of rules having a condition associated with therespective unique condition type. The system may generate a treestructure based on the plurality of rules and the plurality of conditionfrequency counts. The tree structure may include a root node and one ormore node branches, where each node branch includes a first-level nodeand zero of more second-level nodes, and each of the first-level nodesand the zero or more second-level nodes include a node condition andzero or more node actions.

In another embodiment, a method for generating a data tree structure forexpediting rule-based decision-making is disclosed. The method mayinclude receiving a rules file comprising a plurality of rules, whereeach rule of the plurality of rules includes one or more conditions andone or more actions and each condition is associated with a conditiontype. The method may further include generating a plurality of conditionfrequency counts in response to reading the rules file. Each of theplurality of condition counts may be associated with a unique conditiontype and each condition frequency count may represent the total numberof rules having a condition associated with the respective uniquecondition type. The method may further include generating a treestructure based on the plurality of rules and the plurality of conditionfrequency counts. The tree structure may include a root node and one ormore node branches, where each node branch includes a first-level nodeand zero of more second-level nodes, and each of the first-level nodesand the zero or more second-level nodes include a node condition andzero or more node actions.

In another embodiment a non-transitory computer-readable medium isdisclosed. The non-transitory computer-readable medium may storeinstructions that, when executed by one or more processors, cause asystem to receive a rules file comprising a plurality of rules, whereeach rule of the plurality of rules includes one or more conditions andone or more actions and each condition is associated with a conditiontype. The system may generate a plurality of condition frequency countsin response to reading the rules file. Each of the plurality ofcondition counts may be associated with a unique condition type and eachcondition frequency count may represent the total number of rules havinga condition associated with the respective unique condition type. Thesystem may generate a tree structure based on the plurality of rules andthe plurality of condition frequency counts. The tree structure mayinclude a root node and one or more node branches, where each nodebranch includes a first-level node and zero of more second-level nodes,and each of the first-level nodes and the zero or more second-levelnodes include a node condition and zero or more node actions.

Reference will now be made in detail to exemplary embodiments of thedisclosed technology, examples of which are illustrated in theaccompanying drawings and disclosed herein. Wherever convenient, thesame references numbers will be used throughout the drawings to refer tothe same or like parts.

FIG. 1 is a diagram of an exemplary system 100 that may be configured toperform one or more methods disclosed herein, including methods forprocessing high volumes of rules and methods for expediting rule-baseddata processing. The components and arrangements shown in FIG. 1 are notintended to limit the disclosed embodiments as the components used toimplement the disclosed processes and features may vary. As shown,system 100 may include a user device 102, a network 106, a third partyserver 126, and an organization 108 including, for example, a web server110, a call center server 112, a transaction server 114, a local network116, a database 118, a rules processing device 120, a rules storagedevice 122, and an employee terminal 128.

In some embodiments, a customer may operate user device 102. User device102 can include one or more of a mobile device, smart phone, generalpurpose computer, tablet computer, laptop computer, telephone, PSTNlandline, smart wearable device, voice command device, other mobilecomputing device, or any other device capable of communicating withnetwork 106 and ultimately communicating with one or more components oforganization 108. In some embodiments, a user device may include orincorporate electronic communication devices for hearing or visionimpaired users. User device 102 may belong to or be provided by acustomer, or may be borrowed, rented, or shared. Customers may includeindividuals such as, for example, subscribers, clients, prospectiveclients, or customers of an entity associated with organization 108,such as individuals who have obtained, will obtain, or may obtain aproduct, service, or consultation from an entity associated withorganization 108. According to some embodiments, user device 102 mayinclude an environmental sensor for obtaining audio or visual data, suchas a microphone and/or digital camera, a geographic location sensor fordetermining the location of the device, an input/output device such as atransceiver for sending and receiving data, a display for displayingdigital images, one or more processors including a sentiment depictionprocessor, and a memory in communication with the one or moreprocessors. According to some embodiments, user device 102 may beutilized to generate data may be used to generate or populate an inputrequest, such as for example, a loan application form.

Network 106 may be of any suitable type, including individualconnections via the internet such as cellular or WiFi networks. In someembodiments, network 106 may connect terminals, services, and mobiledevices using direct connections such as radio-frequency identification(RFID), near-field communication (NFC), Bluetooth™, low-energyBluetooth™ (BLE), WiFi™, ZigBee™, ambient backscatter communications(ABC) protocols, USB, WAN, or LAN. Because the information transmittedmay be personal or confidential, security concerns may dictate one ormore of these types of connections be encrypted or otherwise secured. Insome embodiments, however, the information being transmitted may be lesspersonal, and therefore the network connections may be selected forconvenience over security.

Network 106 may comprise any type of computer networking arrangementused to exchange data. For example, network 106 may be the Internet, aprivate data network, virtual private network using a public network,and/or other suitable connection(s) that enables components in systemenvironment 100 to send and receive information between the componentsof system 100. Network 106 may also include a public switched telephonenetwork (“PSTN”) and/or a wireless network.

Organization 108 may be associated with an entity such as a business,corporation, individual, partnership, or any other entity that providesone or more of goods, services, and consultations to individuals such ascustomers.

Organization 108 may include one or more servers, devices, and computersystems for performing one or more functions associated with productsand/or services that organization 108 provides. Such servers, devices,and computer systems may include, for example, web server 110, callcenter server 112, transaction server 114, database 118, rulesprocessing device 120, rules storage device 122, and one or moreemployee terminals 128, as well as any other computer systems necessaryto accomplish tasks associated with organization 108 or the needs ofcustomers (which may be customers of the entity associated withorganization 108).

Web server 110 may include a computer system configured to generate andprovide one or more websites accessible to customers, as well as anyother individuals involved in organization 108's normal operations. Webserver 110 may include a computer system configured to receivecommunications from a user device 102 via for example, a mobileapplication, a chat program, an instant messaging program, avoice-to-text program, an SMS message, email, or any other type orformat of written or electronic communication. Web server 110 may haveone or more processors 132 and one or more web server databases 134,which may be any suitable repository of website data. Information storedin web server 110 may be accessed (e.g., retrieved, updated, and addedto) via local network 116 and/or network 106 by one or more devices(e.g., rules processing device 120) of system 100. According to someembodiments, web server 110 may host one or more editable forms, such asloan application forms, that may be filled out by a customer (e.g., viauser device 102) to create an input request that may be processed by thesystem (e.g., by rules processing device 120). In some embodiments, webserver 110 may receive an input request from, for example, user device102, via email, FTP, instant messaging, or any other suitable method oftransmitting information.

Call center server 112 may include a computer system configured toreceive, process, and route telephone calls and other electroniccommunications with a customer operating user device 102. Call centerserver 112 may have one or more processors 142 and one or more callcenter databases 144, which may be any suitable repository of callcenter data. Information stored in call center server 112 may beaccessed (e.g., retrieved, updated, and added to) via local network 116and/or network 106 by one or more devices (e.g., rules processing device120) of system 100. In some embodiments, call center server processor142 may be used to implement an interactive voice response (IVR) systemthat interacts with the customer over the phone. In some embodiments,call center server 112 may generate an input request that may beprocessed by the system (e.g., via rules processing device 120) based onoral responses or statements made by a customer while interacting withcall center server 112.

Transaction server 114 may include a computer system configured toprocess one or more transactions involving an account associated with acustomer, or a request received from customers. In some embodiments,transactions can include, for example, a product/service purchase,product/service return, financial transfer, financial deposit, financialwithdrawal, financial credit, financial debit, dispute request, warrantycoverage request, and any other type of transaction associated with theproducts and/or services that an entity associated with organization 108provides to individuals such as customers. Transaction server 114 mayhave one or more processors 152 and one or more transaction serverdatabases 154, which may be any suitable repository of transaction data.Information stored in transaction server 114 may be accessed (e.g.,retrieved, updated, and added to) via local network 116 and/or network106 by one or more devices (e.g., rules processing device 120) of system100. In some embodiments transaction server 114 may be accessed byanother device of the system 100 (e.g., rules processing device 120) inresponse to supplement data included in an input request. For example,if a customer submits a loan application and fails to fill out a portionof the application that asks for information on credit card balances ormonthly expenditures, rules processing device 120 may access data storedon transaction server 114 and may add information to the input requestbased on the data stored on transaction server 114.

Local network 116 may comprise any type of computer networkingarrangement used to exchange data in a localized area, such as WiFi,Bluetooth™ Ethernet, and other suitable network connections that enablecomponents of organization 108 to interact with one another and toconnect to network 106 for interacting with components in systemenvironment 100. In some embodiments, local network 116 may comprise aninterface for communicating with or linking to network 106. In otherembodiments, components of organization 108 may communicate via network106, without a separate local network 116.

According to some embodiments, database 118 may be a database associatedwith organization 108 and/or its related entity that may store a varietyof information relating to customers, transactions, rules, products andservices, lines of business, and other business operations. Database 118may also serve as a back-up storage device and may contain data andinformation that is also stored on, for example, local databasesassociated with web server 110, call center server 112, transactionserver 114, rules processing device 120, rules storage device 122, andemployee terminal 128. Database 118 may be accessed by other devices(e.g., rules processing device 120) and may be used to store records ofevery interaction, communication, and/or transaction a particularcustomer has had with organization 108 and/or its related entity.

Rules processing device 120 may include a computer system configured toreceive a rules file and generate a tree structure based on the rulesfile. A rules file may be a file that contains a plurality of rules. Arule may be a set of one or more conditions that, when all met, causeone or more associated actions to be executed. For example, a rule maybe “if a customer salary>$70,000, than a minimum down payment of 3% isrequired.” In this case, the condition is the minimum salary specifiedin the rule, and the action is the minimum down payment percentage thatis required if that condition is met. The tree structure generated byrules processing device may be a hierarchy of singly linked nodes. Eachnode may have a node condition and zero or more node actions. The treestructure may have a root node and one or more node branches that arelinked to the root node. A node branch may be a set of linked nodes thatall have a first condition in common. In some embodiments, the top-levelnodes of each node branch may be referred to as first-level nodes. Anode branch may include sub-branches of linked nodes beneath the firstnode of the branch, where the nodes of the sub-branch all have a secondcondition in common. In some embodiments, the top-level nodes of eachsub-branch may be referred to as second-level nodes. The tree structuremay include any number of branches that have any number of sub-branches.Further, sub-branches may have their own sub-branches and thosesub-branches may have their own sub-branches and so on.

Rules processing device 120 may be configured to receive an inputrequest, such as a loan application form, and may process the requestusing the tree structure formed from the rules file. An input requestmay include data that represent input conditions that may be compared toa condition of a node to determine if the condition has been met or not.According to some embodiments, rules processing device 120 may perform abreadth-first traversal of the tree structure, meaning that it processesall of the nodes on the same level (e.g., all first-level nodes) beforetraversing to the nodes in the next level down. Accordingly, rulesprocessing device 120 may begin processing the input request bybeginning at the root node of the tree structure and traversing to thefirst-level nodes linked immediately below the root node and comparingthe input conditions of the input request to the conditions of eachfirst-level node. According to some embodiments, if rules processingdevice 120 determines that the condition of a particular first-levelnode is not met by the input conditions, then rules processing device120 may eliminate the associated branch from further processing withrespect to the input request. If rules processing device 120 determinesthat the condition of a particular first-second node is met by the inputconditions, then rules processing device 120 may cause any node actionassociated with the first-level node to be executed, and rulesprocessing device 120 may traverse down the branch to the second-levelnodes after it is completed processing of all of the first-level nodes.

Upon traversing to the second-level nodes, rules processing device 120may follow the same process of comparing the input conditions to eachcondition of each second-level node, eliminating sub-branches of nodesthat have conditions that are not satisfied, executing node actions ofnodes that have conditions that are satisfied, and then traversing downto third-level nodes that are linked to second-level nodes that haveconditions that are satisfied by the input conditions. When rulesprocessing device 120 traverses to a particle node, it may process thenode by reading the node condition associated with the node andcomparing it to the input conditions of the input request to determineif the node condition has been met. According to some embodiments, anytime the rules processing device 120 determines that a node condition ofa node is satisfied by the input conditions, it may cause any associatednode action to be executed and may designate the branch or sub-branchbeneath the node containing the satisfied condition as requiring futuretraversal by rules processing device 120. Rules processing device 120may traverse down the remainder of the tree structure in this fashion,eliminating sub-branches in which node condition of the top node of thesub-branch is not satisfied and continuing to traverse down sub-branchesin which the top node of the sub-branch is satisfied. In this way, rulesprocessing device 120 may be very efficient in processing an inputrequest because it only traverses branches of the tree structure thatmeet the input conditions of the input request while avoiding having toprocess branches and sub-branches that do not meet the input conditionsof the input request. In some embodiments, when rules processing device120 has concluded traversing the tree in this manner, rules processingdevice may generate output data representing the results of the executednode actions.

According to some embodiments, each node action may have an associatedpriority level so that if there are any conflicting executed nodeactions, the node actions with the highest priority will execute overconflicting node actions with lower priorities. Accordingly, in someembodiments, rules processing device 120 may complete its traversal ofthe tree before causing any particular node action to execute, but mayrather mark node actions for future execution in response to the nodeconditions being met. Accordingly, in some embodiments, before executingany node actions, rules processing device 120 may first check to see ifa particular node action attempts to modify the same variable as one ormore other node actions that have been designated for execution, and ifit does, rules processing device 120 may check the priorities of eachnode action and only execute the node action with the highest priority.Upon executing all of the node actions, rules processing device 120 maygenerate an output map representing all of the data generated by theexecuted node actions. According to some embodiments, an output map maybe a map of key values that identify the actions that were invoked whilematching conditions. For example, in one instance, an output map mayspecify that maxWarranty=2000, minAtf=4000, and minDP=1000.

Rules storage device 122 may include a computer system configured tostore, manage, and update a rules file containing a plurality of rules.A rules file may store a large number (i.e., a high volume) of rules.For example, in some embodiments, a rules file may store millions ofrules. As described above, each rule of a rules file may include one ormore conditions and one or more actions. Each condition may have acondition type. For example, examples of condition types relating to aset of rules that may be used in assessing a loan application for avehicle may be line-of-business (lob) in, a tier in, borrower minimumincome, vehicle maximum age, vehicle maximum mileage, vehicle make,model or condition, vehicle book value, a version number or any othercondition that may be relevant to assessing whether or not to issue aloan or under what circumstances. A line-of-business may represent theline-of-business that a loan application relates to (e.g., whether aloan application was received via a website, received via a dealer, orreceived from a third party or some other method). Further, in someembodiments, a line-of-business may segmented based on an associatedcredit score and/or other credit qualities of the borrower(s), such thatlines of business may segmented by both origination and credit into, forexample, dealer-prime, dealer-subprime, dealer-near-prime, etc. A tierin may represent a segment of business (e.g., sub-prime, near-prime, orprime credit tiers). According to some embodiments, there may be ten ormore tiers that are assigned based on a borrower's credit history,employment status, bankruptcy history, and other such factors that mayimpact a borrower's credit-worthiness. In some embodiments, tiers 0through 4 may be considered to be prime, tiers 5 through 9 may beconsidered to be subprime, and tiers 5 to 6 may be considered to benear-prime. Accordingly, in some embodiments, a tier in may be anynumber from 0 to 9 that represents the tier value associated with acustomer that may be, for example, applying for a loan. A version numbermay represent the version of the rules file that a rule was created inassociation with. It should be understood that these condition types aremerely exemplary and although the previous example provides examplecondition types relating to assessing an application for a vehicle loan,there may be any number of different condition types based on the usecase that the system is applied to.

A rules file may be a file format that is easily accessible andmodifiable by employees with minimum training. For example, a rules filemay be, without limitation, a CSV file, a spreadsheet file, or adatabase table. A rules file may be stored in a document managementsystem of rules storage device 122 that is capable of storing andmaintaining different versions of rules file. According to someembodiments, a rules file may be updated intermittently, and eachupdated version of a particular rules file may be given a new versionnumber to track the version of the rules file.

Third party server 126 may include a computer system configured tostore, manage, and update a rules file containing a plurality of rules.As shown in FIG. 1, third party server may be a computer system ordevice that may be positioned externally to organization 108 and may beaccessed via network 106. For example, third party server may be a cloudstorage system or device that allows a rules file to be accessed andupdated from any device that is connected to network 106. In this way,employees and other users may be able to easily access and update arules file without the need to access rules processing device 120. Arules file may be stored in a document management system of third partyserver 122 that is capable of storing and maintaining different versionsof rules file.

Employee terminal 128 may be, but is not limited to a terminal, adesktop computer, a laptop computer, a mobile device such as a smartphone or tablet device, and any other computerized devices configured tocommunicate with local network 116 to perform various functions relatingto organization 108 such as, for example, receiving and displaying datasuch as input requests and data output by rules processing device.Employee terminal 128 may enable an employee of an entity associatedwith organization 108 to access and modify a rules file stored on, forexample, rules storage device. Employee terminal 128 may includefunctionality that enables an employee to initiate a transfer of a rulesfile to rules processing device 120 for loading and processing. Employeeterminal 128 may further include functionality to enable an employee todirect an input request to be sent to rules processing device 120 forprocessing.

Although the preceding description describes various functions of webserver 110, call center server 112, transaction server 114, database118, rules processing device 120, rules storage device 122, third partyserver 126, and employee terminal 128 in some embodiments, some or allof these functions may be carried out by a single computing device.

For ease of discussion, embodiments may be described in connection withthe expediting rule-based data processing in relation to a loanapplication process. It is to be understood, however, that disclosedembodiments are not limited to processing loan applications, but mayrelate to any context where rules are applied to input to determine anoutput, such as any type of underwriting (e.g., mortgage, insurance,etc.), reservation systems, customer suggestion systems, or any othercontext in which processing a set of input data through a large numberof rules to generate an output may be useful. Further, steps orprocesses disclosed herein are not limited to being performed in theorder described, but may be performed in any order, and some steps maybe omitted, consistent with the disclosed embodiments.

The features and other aspects and principles of the disclosedembodiments may be implemented in various environments. Suchenvironments and related applications may be specifically constructedfor performing the various processes and operations of the disclosedembodiments or they may include a general purpose computer or computingplatform selectively activated or reconfigured by program code toprovide the necessary functionality. Further, the processes disclosedherein may be implemented by a suitable combination of hardware,software, and/or firmware. For example, the disclosed embodiments mayimplement general purpose machines configured to execute softwareprograms that perform processes consistent with the disclosedembodiments. Alternatively, the disclosed embodiments may implement aspecialized apparatus or system configured to execute software programsthat perform processes consistent with the disclosed embodiments.Furthermore, although some disclosed embodiments may be implemented bygeneral purpose machines as computer processing instructions, all or aportion of the functionality of the disclosed embodiments may beimplemented instead in dedicated electronics hardware.

The disclosed embodiments also relate to tangible and non-transitorycomputer readable media that include program instructions or programcode that, when executed by one or more processors, perform one or morecomputer-implemented operations. The program instructions or programcode may include specially designed and constructed instructions orcode, and/or instructions and code well-known and available to thosehaving ordinary skill in the computer software arts. For example, thedisclosed embodiments may execute high level and/or low level softwareinstructions, such as machine code (e.g., such as that produced by acompiler) and/or high level code that can be executed by a processorusing an interpreter.

An exemplary embodiment of rules processing device 120 is shown in moredetail in FIG. 2. Web server 110, call center server 112, transactionserver 114, rules storage device 122, third party server 126, employeeterminal 128 and/or user device 102 may have a similar structure and mayinclude many components that are similar to or even have the samecapabilities as those described with respect to rules processing device120. As shown, rules processing device 120 may include a processor 210,an input/output (“I/O”) device 220, a memory 230 containing an operatingsystem (“OS”) 240 and a program 250. For example, rules processingdevice 120 may be a single device or server or may be configured as adistributed computer system including multiple servers, devices, orcomputers that interoperate to perform one or more of the processes andfunctionalities associated with the disclosed embodiments. In someembodiments, rules processing device 120 may further include aperipheral interface, a transceiver, a mobile network interface incommunication with the processor 210, a bus configured to facilitatecommunication between the various components of the rules processingdevice 120, and a power source configured to power one or morecomponents of the rules processing device 120.

A peripheral interface may include hardware, firmware and/or softwarethat enables communication with various peripheral devices, such asmedia drives (e.g., magnetic disk, solid state, or optical disk drives),other processing devices, or any other input source used in connectionwith the instant techniques. In some embodiments, a peripheral interfacemay include a serial port, a parallel port, a general purpose input andoutput (GPIO) port, a game port, a universal serial bus (USB), amicro-USB port, a high definition multimedia (HDMI) port, a video port,an audio port, a Bluetooth™ port, a near-field communication (NFC) port,another like communication interface, or any combination thereof.

In some embodiments, a transceiver may be configured to communicate withcompatible devices and ID tags when they are within a predeterminedrange. A transceiver may be compatible with one or more of:radio-frequency identification (RFID), near-field communication (NFC),Bluetooth™, low-energy Bluetooth™ (BLE), WiFi™, ZigBee™, ambientbackscatter communications (ABC) protocols or similar technologies.

A mobile network interface may provide access to a cellular network, theInternet, a local area network, or another wide-area network. In someembodiments, a mobile network interface may include hardware, firmware,and/or software that allows the processor(s) 210 to communicate withother devices via wired or wireless networks, whether local or widearea, private or public, as known in the art. A power source may beconfigured to provide an appropriate alternating current (AC) or directcurrent (DC) to power components.

Processor 210 may include one or more of a microprocessor,microcontroller, digital signal processor, co-processor or the like orcombinations thereof capable of executing stored instructions andoperating upon stored data. Memory 230 may include, in someimplementations, one or more suitable types of memory (e.g. such asvolatile or non-volatile memory, random access memory (RAM), read onlymemory (ROM), programmable read-only memory (PROM), erasableprogrammable read-only memory (EPROM), electrically erasableprogrammable read-only memory (EEPROM), magnetic disks, optical disks,floppy disks, hard disks, removable cartridges, flash memory, aredundant array of independent disks (RAID), and the like), for storingfiles including an operating system, application programs (including,for example, a web browser application, a widget or gadget engine, andor other applications, as necessary), executable instructions and data.In one embodiment, the processing techniques described herein areimplemented as a combination of executable instructions and data withinthe memory 230.

Processor 210 may be one or more known processing devices, such as amicroprocessor from the Pentium™ family manufactured by Intel™ or theTurion™ family manufactured by AMD™. Processor 210 may constitute asingle core or multiple core processor that executes parallel processessimultaneously. For example, processor 210 may be a single coreprocessor that is configured with virtual processing technologies. Incertain embodiments, processor 210 may use logical processors tosimultaneously execute and control multiple processes. Processor 210 mayimplement virtual machine technologies, or other similar knowntechnologies to provide the ability to execute, control, run,manipulate, store, etc. multiple software processes, applications,programs, etc. One of ordinary skill in the art would understand thatother types of processor arrangements could be implemented that providefor the capabilities disclosed herein.

Rules processing device 120 may include one or more storage devicesconfigured to store information used by processor 210 (or othercomponents) to perform certain functions related to the disclosedembodiments. In some embodiments, rules processing device 120 mayinclude memory 230 that includes instructions to enable processor 210 toexecute one or more applications, such as server applications, networkcommunication processes, and any other type of application or softwareknown to be available on computer systems. Alternatively, theinstructions, application programs, etc. may be stored in an externalstorage or available from a memory over a network. The one or morestorage devices may be a volatile or non-volatile, magnetic,semiconductor, tape, optical, removable, non-removable, or other type ofstorage device or tangible computer-readable medium.

In one embodiment, rules processing device 120 may include memory 230that includes instructions that, when executed by processor 210, performone or more processes consistent with the functionalities disclosedherein. Methods, systems, and articles of manufacture consistent withdisclosed embodiments are not limited to separate programs or computersconfigured to perform dedicated tasks. For example, rules processingdevice 120 may include memory 230 that may include one or more programs250 to perform one or more functions of the disclosed embodiments.Moreover, processor 210 may execute one or more programs 250 locatedremotely from system 100. For example, system 100 may access one or moreremote programs 250, that, when executed, perform functions related todisclosed embodiments. In some embodiments, rules processing device 120may include a tree structure generation program 250 that is a programconfigured to convert a plurality of rules that are provided in a rulesfile into a tree structure that may be traversed in accordance with aninput request to generate executed actions as described below.

Memory 230 may include one or more memory devices that store data andinstructions used to perform one or more features of the disclosedembodiments. Memory 230 may also include any combination of one or moredatabases controlled by memory controller devices (e.g., server(s),etc.) or software, such as document management systems, Microsoft™ SQLdatabases, SharePoint™ databases, Oracle™ databases, Sybase™ databases,or other relational or non-relational databases. Memory 230 may includesoftware components that, when executed by processor 210, perform one ormore processes consistent with the disclosed embodiments. In someembodiments, memory 230 may include a database 260 for storing relateddata to enable rules processing device 120 to perform one or more of theprocesses and functionalities associated with the disclosed embodiments.

Rules processing device 120 may also be communicatively connected to oneor more memory devices (e.g., databases) locally or through a network.The remote memory devices may be configured to store information and maybe accessed and/or managed by rules processing device 120. By way ofexample, the remote memory devices may be document management systems,Microsoft™ SQL database, SharePoint™ databases, Oracle™ databases,Sybase™ databases, or other relational or non-relational databases.Systems and methods consistent with disclosed embodiments, however, arenot limited to separate databases or even to the use of a database.

Rules processing device 120 may also include one or more I/O devices 220that may comprise one or more interfaces for receiving signals or inputfrom devices and providing signals or output to one or more devices thatallow data to be received and/or transmitted rules processing device120. For example, rules processing device 120 may include interfacecomponents, which may provide interfaces to one or more input devices,such as one or more keyboards, mouse devices, touch screens, track pads,trackballs, scroll wheels, digital cameras, microphones, sensors, andthe like, that enable rules processing device 120 to receive data fromone or more users (such as, for example, via user device 102).

In exemplary embodiments of the disclosed technology, rules processingdevice 120 may include any number of hardware and/or softwareapplications that are executed to facilitate any of the operations. Theone or more I/O interfaces may be utilized to receive or collect dataand/or user instructions from a wide variety of input devices. Receiveddata may be processed by one or more computer processors as desired invarious implementations of the disclosed technology and/or stored in oneor more memory devices.

While web server 110, call center server 112, transaction server 114,rules processing device 120, rules storage device 122, third partyserver 126, employee terminal 128, and user device 102 have beendescribed as one form for implementing the techniques described herein,those having ordinary skill in the art will appreciate that other,functionally equivalent techniques may be employed. For example, asknown in the art, some or all of the functionality implemented viaexecutable instructions may also be implemented using firmware and/orhardware devices such as application specific integrated circuits(ASICs), programmable logic arrays, state machines, etc. Furthermore,other implementations of the web server 110, call center server 112,transaction server 114, rules processing device 120, rules storagedevice 122, third party server 126, employee terminal 128, and userdevice 102 may include a greater or lesser number of components thanthose illustrated.

FIG. 5 shows a flowchart of an exemplary method 500 for expeditingrule-based data processing. Method 500 may be performed by some or allof web server 110, call center server 112, transaction server 114,database 118, rules processing device 120, rules storage device 122,third party server 126, employee terminal 128, and user device 102.

In block 510, rules processing device 120 may receive a rules file(e.g., a rules file 300 as shown in FIG. 3) that includes a plurality ofrules. Each rule of the plurality of rules may include one or moreconditions and one or more actions. According to some embodiments, eachcondition may be associated with a condition type. As shown in theexemplary embodiment in FIG. 3, rules file 300 may be in the form of atable that has a plurality of rows and a plurality of columns. Accordingto some embodiments, each row may represent a single rule, as indicatedby the rule name column 302. In the example shown in FIG. 3, there aresix rules, and each rule includes up to three condition types and up tofour actions. The three possible condition types correspond to the “Lobin” column 304 that indicates a particular line of business, the “Tierin” column 306 that indicates a particular tier, and a “Version” column308 that indicates the version of the rules file associated with therule. The four possible actions correspond to the “minIncome” column 310that specifies a minimum income, the “maxWarranty” column 312 thatspecifies a maximum warranty, a “minAtf” column 314 that specifies aminimum amount to finance, and a “minDP” column 316 that specifies aminimum down payment. According to some embodiments, if a conditionfield or an action field of a particular rule is blank, rules processingdevice 120 may determine that it does have a condition or an actionassociated with the condition type or action type that associated withthe respective field.

A field that is positioned at the intersection of a row of a rule and acolumn of a condition type may specify a condition that must besatisfied to meet the rule. For example, the field 320 in the Lob incolumn 304 of the Rule 1 row specifies a condition that the line ofbusiness of an input request must be one of “201,” “301,” or “350” inorder to meet the condition. According to some embodiments, conditionsmay be input as a parenthetical list of possible data entries that wouldsatisfy the condition, Boolean operations, or mathematical operations.Examples of conditions may be “tier is {‘0’, ‘1’, ‘2’ }” which issatisfied if the tier input is any of “0”, “1”, or “2”, or “minIncome is{>1000}” which is satisfied if the corresponding income input is greaterthan 1000. According to some embodiments, conditions may utilize one ormore of >, <, >=, <=, !=, =. Further, in some embodiments, conditionsmay include dates and/or times (including ranges) that may be comparedagainst input data, or may include condition data that may be comparedagainst input data to determine if the input data contains or includesthe condition data or vice versa. Each field that is located at theintersection of a row of a rule and a column of an action may specifythe action to be executed by the system if all of the conditions of theapplicable rule are met. For example, field 330 in the minIncome column310 of the Rule 1 row specifies an output value for a minimum incomethat is 1500. Accordingly, in the example embodiment shown in FIG. 3, ifthe conditions associated with Rule 1 are all met, then rules processingdevice 120 may cause the action to be executed, thereby outputting“1500” as a minimum income value.

According to some embodiments, rules processing device 120 may convertthe conditions and actions to an expected data type to avoid the need toconvert data during the processing phase. For example, a numeric valuemay be of different types such as Integer (i.e., whole numbers) vs.Double (i.e., high precision float numbers), and to compare two valuesin a given computer programming language, it may be necessary to convertthe data to the same data type. For example, a condition may be“minIncome<1800” meaning that the minimum income is less than$1800/month and because 1800 is a whole number, the system may store the1800 as an Integer type. However, if the reported income in a loanapplication (i.e., the input data) is $1825.40, this number may bestored as a Double type because it is a decimal number. Thus, in thisexample, it would be necessary to convert the 1800 from an Integer typeto a Double type prior to running the comparison between the two. Ifthis conversion takes place during traversal of the tree structure, itwould be necessary to perform the conversion every time the tree istraversed and therefore the conversion would be very costly in terms ofhigh processing volume. Accordingly, to reduce the processing cost, itmay be advantageous to convert the conditions and actions to an expecteddata type to avoid having to convert them during processing of the rulestree. Thus, in some embodiments, each condition and action data may beconverted to an expected data type prior to the traversal of the treestructure. An expected data type may be determined by, for example,referencing a table of expected data types that specifies what theexpected data type for each condition and action should be andconverting each condition or action data to the associated expected datatype. As described above, according to some embodiments, this conversionof conditions and actions to an expected data type may occur only onceat during the loading of the tree in memory, as opposed to performingthe conversion each time the tree is traversed.

In block 520, rules processing device 120 may generate a plurality ofcondition frequency counts. According to some embodiments, the pluralityof condition frequency counts may be generated in response to readingthe rules file 300 and counting the number of rules having a conditionin a field that is associated with a particular condition type.According to some embodiments, rules processing device 120 may generatea condition frequency count for each unique condition type. According tosome embodiments, in the course of generating the plurality of conditionfrequency counts, rule processing device 120 may ignore blank fields inthe condition columns (e.g., columns 304, 306, 308) and only countfields that contain a condition. For example, as shown in the exemplaryembodiment in FIG. 3, Rules 1, 2, 3, and 6 each specify conditions inthe Lob in column 304 and thus the “Lob in” condition type may have acondition frequency count of four. Similarly, the “Tier in” conditiontype may have a condition frequency count of two and the “Version”condition type may have a condition frequency of six.

In block 530, rules processing device 120 may generate a tree structure(e.g., a tree structure 400 as shown in FIG. 4). The tree structuregenerated by rules processing device 120 may include a root node and oneor more node branches. In general, a root node may be used to hold thereference to the entire tree structure and to allow for grouping of setsof like rules into “rule sets” that can be executed together. Thisgrouping of like rules together may be performed outside of the rulesprocessing device 120 by, for example, grouping together a plurality ofrules files together that perform a single operation. This may beperformed by maintaining a list of root nodes that need to be executedto achieve a particular decision. For example, processing a creditapplication before pricing the APR may require running a base set ofpolicy rules that generate actions that feed into an additional set ofrules designed to determine APR pricing. According to some embodiments,the root node may not include any conditions or actions, but may simplyserve as a default starting point for the formation of the treestructure. In some embodiments, the root note may not include anyconditions, but may include one or more actions if there are someuniversal actions (e.g., if the minimum loan amount to finance is $4000regardless of all other circumstances, then the root node may includesuch an action). According to some embodiments, each node branch of treestructure 400 may include a first-level 410 node and zero or moresecond-level 420 nodes. For example, as shown in FIG. 4, tree structure400 may have a root node 402 and a first branch beginning with afirst-level node 412 and including second-level nodes 422, 424, 426 andthird-level nodes 432, 434, 436. Although the exemplary embodiment shownin FIG. 4 only shows one branch linked below root node 402, the branchhas multiple sub-branches. For example, the branch beginning with node412 has a first sub-branch 452 comprising three nodes 422, 432, 436, asecond sub-branch 454 comprising two nodes 424, 434, and a thirdsub-branch 456 comprising a single node 426. The terms branch andsub-branch may be used to indicate a sub-set of linked nodes that arelinked below a top node. Although the term sub-branch may generallyrefer to a second branch of nodes that branches off of a first branch ofnodes, sub-branches may also be referred to as branches. A top node maybe the first node in a branch or a sub-branch. One or more nodes linkedone level below a top node may be referred to as child nodes orchildren. For example, as shown in FIG. 4, second-level 420 node 422 maybe considered to be the top node of branch 452 and third-level 430 nodes432, 436 may be referred to as its child nodes.

According to some embodiments, rules processing device 120 may generatetree structure (e.g., tree structure 400) based on the plurality ofrules and the plurality of condition frequency counts determined atblock 520. For example, according to some embodiments, rules processingdevice 120 may utilize a method 530 or a method 700 for generating thetree structure based on the plurality of rules and the plurality ofcondition frequency counts as described in greater detail with respectto FIGS. 6 and 7 below. In some embodiments, rules processing device 120may generate tree structure 400 using an iterative process of accountingfor each condition of a particular rule by checking the child nodes of atop node to see if any of the children includes the condition. If thechild nodes of the top node do not include the condition-to-be-added,then rules processing device 120 may create a new child node thatincludes the condition-to-be-added. If one of the child nodes of the topnode matches the condition-to-be-added, then rules processing device 120may designate that child node as being the new top node and rulesprocessing device 120 may select a second condition-to-be-added from thecurrent rule and compare it to the child nodes of the new top node inthe same manner. When the last condition of a particular rule has beenaccounted for (e.g., by either being added as a new child node or beingidentified as already being present in a node of the tree), then anyactions associated with the rule are then added to the tree structureeither at the node that was either newly created to include thecondition or the node that was recognized to already include thecondition.

According to some embodiments, each node of the tree structure 400except the root node 412 may have a node condition and zero or more nodeactions. As previously state above, a root node may have no conditions,but may have zero or more association actions. Accordingly, eachfirst-level 410 node, second-level 420 node, and third-level 430 nodemay have a node condition and zero or more node actions, while root node402 has neither a condition nor an action. Although the exemplaryembodiment in FIG. 4 illustrates tree structure 400 having a first-level410, a second-level 420, and a third-level 430 of nodes, it should beunderstood that in some embodiments tree structure 400 may have anynumber of further levels of nodes beyond the third-level 430 of nodes432, 434, 436 depicted in FIG. 4. For example, tree structure 400generated by system 100 may have tens of levels.

In block 540, rules processing device 120 may receive an input requestthat includes one or more input conditions. Rules processing device 120may receive the input request from, for example, employee terminal 128,web server 110, call center server 112, or user device 102. As describedabove, an input request may include data that represents a number ofinput conditions. For example, an input request may be a loanapplication that specifies or was determined to have, for example, aversion of 1.00, a line of business (lob in) of 201, and a tier (i.e.,tier in) of 7.

In block 550, rules processing device 120 may traverse one or more nodebranches of the tree structure and execute zero or more node actions inthe traversed one or more node branches. In some embodiments, thetraversal of the one or more node branches of the tree structure may beperformed based on the input conditions. For example, as previouslydescribed above, rules processing device 120 may traverse tree structure400 by comparing the input conditions of the input request to acondition of a node of the tree structure to determine if the conditionof the node is met. If rules processing device 120 determines that thecondition of a current node is not met, then rules processing device 120may eliminate the branch or sub-branch of linked nodes below the currentnode from further processing. If rules processing device 120 determinesthat the condition of the current node is met, then rules processingdevice 120 may cause zero or more actions associated with the currentnode to be executed and may designate the sub-branch of linked nodesbelow the current node as requiring further processing with respect tothe input request. For example, in response to traversing each node ofthe first-level 410 of nodes, rules processing device 120 may determinea first subset of first-level 410 nodes that have conditions that aresatisfied by the input conditions of the input request and a secondsubset of first-level 410 nodes that have conditions that are notsatisfied by the input conditions of the input request and, followingthe traversal of all of the first-level 410 nodes, rules processingdevice 120 may traverse to one or more nodes in the second-level 420 ofnodes that are linked to one or more nodes of the first subset offirst-level 410 nodes. Accordingly, based on the input conditions, rulesprocessing device 120 may traverse one or more node branches of the treestructure 400 and execute zero or more node actions in the traversed oneor more node branches, while eliminating node branches and sub-branchesfrom processing that do not have a top level node that has a conditionthat is met by the input conditions of the input request. Rulesprocessing device 120 may use an iterative process to traverse down eachlevel of the tree structure in this manner.

Thus, in an exemplary embodiment where rules processing device 120 hasgenerated tree structure 400 as shown in FIG. 4 and rules processingdevice 120 receives an input request specifies input conditions thatinclude a version of 1.00, a line of business (lob in) of 201, and atier (i.e., tier in) of 7, the traversal of tree structure 400 may beginat root node 412 and rules processing device 120 may compare theconditions of the child nodes of the root node 412 to the inputconditions of the input request to determine if the child nodeconditions are met. Accordingly, rules processing device 120 may comparethe condition of first-level node 410, which states that “version=1.00”to the input conditions and determine that the condition has been met.Accordingly, because the condition of first-level node 412 is satisfied,rules processing device 120 may cause the node actions associated withnode 412 to be executed, meaning that rules processing device 120 mayoutput that a maximum warranty of 2000 and a minimum amount to financeof 4000. After rules processing device 120 has finished traversing allof the first-level 410 nodes, rules processing device 120 may thenproceed to traverse all of the second-level 420 nodes that were not inbranches that were eliminated by rules processing device 120 maytraverse after processing the first-level 410 nodes. For example, asshown in FIG. 4, because there is only one first-level 410 node 412 inthis example and rules processing device 120 has determined that itscondition has been satisfied, rules processing device 120 may proceed totraverse nodes 422, 424, and 426 to determine if their respectiveconditions are satisfied by the input conditions. Because the inputconditions specify that the line of business is 201, rules processingdevice 120 may determine that the conditions of a first second-levelnode 422 and a second second-level node 424 have been met, but thecondition of a third second-level node 426 has not been met.Accordingly, rules processing device 120 may cause the actionsassociated with the first and second second-level 420 nodes to execute,may designate the third-level 430 nodes 432, 434, 436 that are linked tothose nodes 422, 424 for future traversal, and may eliminate the thirdbranch 456 associated with the third second-level node 426 from furtherprocessing. Although the example shown in FIG. 4 does not show the thirdsecond-level node 426 as having any linked third-level 430 nodes, if itwere to have any, rules processing device 120 would not traverse to themor process them following its elimination of the third branch 456. Rulesprocessing device 120 may now perform a traversal of each of thethird-level 430 nodes that were designated for future traversal bycomparing the input conditions to the conditions of third-level nodes432, 434, 436. Because the input conditions specify the tier is tier 7,rules processing device 120 may determine that the condition of a firstthird-level 430 node 432 is not met, but the conditions of a second andthird third-level 430 nodes 434, 436 are met. Accordingly, rulesprocessing device 120 may cause the node actions associated with thesecond and third third-level 430 nodes 434, 436 to be executed (i.e.,outputting a minimum down payment of 1000 and a minimum income of 1800)while ignoring the node action of the first third-level 430 node 432.

FIG. 6 shows a flowchart of an exemplary method 530 for generating treestructure, such as tree structure 400, that may be used as part ofmethod 500 in some embodiments. In block 610, rules processing device120 may generate a root node.

In block 620, rules processing device 120 may prioritize the conditiontypes based on the magnitude of each condition type's respectivecondition frequency count. For example, rules processing device 120 mayassign a priority to each condition type in descending order based onthe plurality of condition frequency counts, such that the conditiontype having the highest condition frequency count has the highestpriority and the condition frequency count having the lowest conditionfrequency count may have the lowest priority. According to someembodiments, if more than one condition type has the same conditionfrequency count, rules processing device 120 may either assign thecondition types the same priority or may arbitrarily assign differentpriorities to each condition type having the same condition frequencycount. Thus, as an example, in the FIG. 3 embodiment, condition type 308(i.e., “Version”) could have a frequency count of six, condition type304 (i.e., “Lob in”) could have a frequency count of four, and conditiontype 306 (i.e., “Tier in”) could have a frequency count of two. Thefrequency count can then be used to prioritize the various conditiontypes (e.g., 304, 306, 308) such that the condition type having thehighest frequency count (i.e., condition 308) will correspond to thehighest priority. In some embodiments, the method can further includesorting the various condition type columns according to their respectivepriorities. For example, in the FIG. 3 embodiment, the condition typecolumns could be resorted to be in order of (1) version condition type308, (2) lob in condition type 304, and (3) tier in condition type 306.In some embodiments, the method may include traversing all rules of therules file to identify rules that include the condition type having thehighest priority and processing the identified set of rules first.

In block 630, rules processing device 120 may process a first first-rulecondition of a first rule by generating a first child node to the rootnode, the first first-rule condition having a condition type of thehighest priority and the first child node having the first first-rulecondition. For example, in the exemplary embodiment shown in FIG. 3,rules processing device 120 may process the highest priority conditionof Rule 1 (i.e., “Version=1.00”) by creating a child node to the rootnode having this condition, as shown by node 412 in FIG. 4.

In block 640, rules processing device 120 may process one or morefirst-rule conditions of the first rule in order of their condition typepriority by, for each first-rule condition, creating a first-rule childnode including the first-rule condition, where the first-rule child nodeis a child node of the previously created first-rule node, and for thelast processed condition, incorporating one or more actions into thelast created first-rule child node. For example, in the exemplaryembodiment shown in FIG. 3, after processing the highest prioritycondition (i.e., “Version=1.00”) of Rule 1, rules processing device 120may process the second highest priority condition (i.e., “Lob in=(201,301,350) by creating a child node to the previously created nodethat has this condition. In other words, as shown in FIG. 4, a childnode 422 to node 412 may be created, where the child node 422 includesthe second highest priority condition of Rule 1 (i.e., “Lob in=(201,301,350). The next highest priority condition of Rule 1 (i.e.,“Tier in =(‘0’,‘1’,‘2’,‘3’,‘4’,‘5’,‘6’,‘7’)) may then be processed byrules processing device 120 in a similar manner to generate node 432,which includes this condition and is a child node of the previouslycreated node 422.

In block 650, rules processing device 120 may process a second rule by,responsive to determining that a first second-rule condition is notincluded in the first child node to the root node, generating a secondchild node to the root node incorporating the first second-rulecondition, wherein the first second-rule condition has a condition typeof the highest priority. For example, although the “Version” conditionof Rule 2 shown in the exemplary embodiment in FIG. 3 is the same as thechild (i.e., node 412) of the root node shown in FIG. 4, if instead the“Version” condition was, for example, “Version=1.01,” then rulesprocessing device 120 would determine that the condition is not includedin the child node of the root node and it would create a new child nodeto the root node (not shown) that would be on the same first level 410as the first child node 412 of the root node. This new child node mayserve as the top node of a new sub-branch of nodes.

Further, rules processing device 120 may process the second rule by,responsive to determining that the first second-rule condition isincluded in the first child node to the root node and that a child nodeof the first child node to the root node does not include a secondsecond-rule condition, creating a second-rule child node including thesecond-rule condition, the second-rule child node being a child of thefirst child node to the root node.

For example, because the “Version” condition (i.e., “Version=1.00”) ofRule 2 shown in the exemplary embodiment in FIG. 3 is included in thecondition of the child node (i.e., node 412) of the root node shown inFIG. 4, rules processing device 120 may determine whether the child nodeof the child node to the root node includes a second condition of therule. For example, in the exemplary embodiment in FIG. 3, rulesprocessing device 120 may determine if a second condition of Rule 2,“Lob in =(201,301,350)” is included in a child node of node 412. In thiscase, the second condition is included in the child node of the childnode of the root node, so rules processing device 120 may take no actionwith respect to this condition. However, if the second condition of Rule2 instead was “Lob in =(201,350),” then because the only child nodewould have been added to node 412 at this point is node 422, thiscondition would not be included in any child nodes of the child node ofthe root node, and accordingly rules processing device 120 may generatea new child node to the child node of the root node, that would, forexample correspond to node 424 in FIG. 4.

According to some embodiments, after all conditions of a particularrule, (e.g., nodes 412, 422, and 432 for Rule 1) are added to the treestructure, rules processing device 120 may identifying any actionsassociated with the rule (e.g., action of action type 310 for Rule 1)and attached the identified action to the last node (i.e., themost-recently added node or the node identified to include the lastcondition of the rule) associated with the rule (i.e., node 432 for Rule1).

As described in more with respect to FIG. 7 below, according to someembodiments, rules processing device 120 may traverse all of the rulesin a rules file and either verify that each condition of a rule isalready included in the tree structure or create a new node toincorporate the condition into the tree structure. In some embodiments,rules processing device 120 may presort the rules before processingthem. For example, after assigning priorities to condition types asdescribed above, rules processing device 120 may sort the rulesaccording to the priority of their associated condition types such thatthe rules that include a condition of the highest condition type arefirst, the rules of the remaining set of rules having a condition of thecondition type of the next highest priority will come next, and so on.

FIG. 7 illustrates a flow chart for another exemplary method 700 ofgenerating tree structure (e.g., tree structure 400) that, according tosome embodiments, may be incorporated into method 500 in place of block530. Accordingly, method 700 may be carried out by, for example, rulesprocessing device 120 to generate a tree structure by processing a rulesfile having a plurality of rules.

At block 702, rules processing device 120 may generate a root node.According to some embodiments, the root node may have no conditions andno actions, but may serve as a reference point for the beginning of atree structure. In some embodiments, a root node may have no conditionsbut may have one or more actions that may be considered to be “universalactions,” meaning that because there are no conditions associated withthem, these actions are always triggered every time the tree structureis traversed in association with an input request or input data.

At block 704, rules processing device 120 may determine if there are anyfurther unprocessed rules in the rules file. According to someembodiments, in response to determining there are no more unprocessedrules in the rules file, method 700 may end. In some embodiments, inresponse to determining that there is another unprocessed rule in therules file, rules processing device 120 may select the next unprocessedrule for processing. For example, if no rules of the rules file havebeen processed, rules processing device 120 may select the first rule inthe rules file for processing. If the first rule has already beenprocessed, rules processing device 120 may select the second rule forprocessing, and so on.

At block 706, rules processing device 120 may sort or prioritize theconditions of the rule in descending order based on the frequency countof the condition type. For example, in the exemplary embodiment shown inFIG. 3, the “Version” condition 308 would have the first priority, the“Lob in” condition would have the second priority, and the “Tier in”condition would have the third priority. Rules processing device 120 mayalso set the current node to be equal to the root node. The current nodemay be the node in which method 700 is currently referencing in order tomake decisions about adding nodes or modifying nodes in tree structure(e.g., tree structure 400). Thus, according to some embodiments, priorto adding a first condition of a new rule to the tree structure, rulesprocessing device 120 may begin the process adding the first conditionby referencing the root node (e.g., root node 402).

At block 708, rules processing device 120 may select the next conditionof the current rule, based on the priority, for processing and adding tothe tree structure. For example, if no conditions of the current rulehave been processed, rules processing device 120 will select the highestpriority condition for processing. In the exemplary embodiment shown inFIG. 3, the highest priority condition of Rule 1 is “Version=1.00.” Ifthe highest priority condition has already been processed, rulesprocessing device 120 may select the next highest priority condition.For example, in the exemplary embodiment shown in FIG. 3, the nexthighest priority condition of Rule 1 is “Lob in =(201,301,350).” Thecurrently selected condition may be referred to as thecondition-to-be-added.

At block 710, rules processing device 120 may compare thecondition-to-be-added to the child nodes of the current node todetermine whether the condition-to-be-added is included in any of thechild nodes of the current node. For example, in the exemplaryembodiment shown in FIG. 3, for the first condition (i.e.,“Version=1.00”) of Rule 1, rules processing device 120 may search thechild nodes of the root node to determine whether any of the child nodesinclude this condition. However, because there are not yet any childnodes of the root node, rules processing device 120 may determine thatthere are no child nodes of the current node that match the currentcondition-to-be-added.

At block 712, in response to determining that none of the child nodes ofthe current node include the condition-to-be-added, rules processingdevice 120 may create a new child node to the current node, where thenew child node includes the condition-to-be-added. Accordingly, in theprevious example in which the root node has no child nodes and thereforeno child nodes of the root node include the first condition of the firstrule, rules processing device 120 may create a new node including thecondition “Version=1.00.” As shown in the exemplary embodiment in FIG.4, this newly created child node corresponds to first-level 410 node412, which is a child node of root node 402 having the “Version=1.00”condition. According to some embodiments, following the creation of thenew child node having the condition-to-be-added, method 700 may proceedto block 716.

However, if at block 712, rules processing device 120 determines that acondition-to-be-added is included in a child node of the current node,then rules processing device 120 may proceed to block 714. At block 714,rules processing device may update the child node of the current nodethat includes the condition-to-be-added. For example, in the exemplaryembodiment shown in FIG. 3, if the condition-to-be-added is thecondition “Version=1.00” of Rule 2, then rules processing device 120 maycompare this condition to the child nodes of the root node and determinethat node 412 includes this condition. Accordingly, rules processingdevice 120 may update the child node that includes thecondition-to-be-added (e.g., node 412) to, for example, store thereference of the rule in the node (e.g., file name, row, rule name,etc.) and then method 700 may proceed to block 716. According to someembodiments, nodes may be updated according to this process to include alist of all of the rules that are embodied by the node to aid indebugging the program should there be any issues.

At block 716, rules processing device 120 may determine whether theprevious condition-to-be-added was the last condition of the currentrule or whether any unprocessed conditions remain. For example, in theexemplary embodiment shown in FIG. 3, after the highest prioritycondition of Rule 1 (i.e., “Version=1.00”) is processed, there are stilltwo remaining conditions of that rule that require processing (i.e.,“Lob in =201,301,350” and “Tier in =(‘0’,‘1’,‘2’,‘3’,‘4’,‘5’,‘6’)). Incontrast, after processing the highest priority condition of Rule 4(i.e., “Version=1.00”) of the exemplary embodiment of FIG. 3, there areno more conditions to be processed in that rule. If rules processingdevice 120 determines that the previous condition-to-be-added is not thelast condition of the current rule that requires processing, method 700may advance to block 718, otherwise method 700 may advance to block 720.

At block 718, rules processing device may set the current node to be oneof either the child node created at block 712 or the child node that wasupdated at block 714, based on whether the child node was found at block710 or not. In other words, if no child node was found to include thecondition-to-be-added in block 710, then at block 718 the current nodewill be set to be the new child node created at block 712, however if achild node was found to include the condition-to-be-added at block 710,then at block 718 the current node will be set to be the child node thatwas updated at block 714. After updating the current node, method 700may proceed to block 708 to obtain the next condition of the currentrule that has not yet been processed.

At block 720, following a determination that the previouscondition-to-be-added was the last condition of the current rule, rulesprocessing device may add the actions associated with the current ruleto one of either the child node created at block 712 or the child nodethat was updated at block 714, based on whether the child node was foundat block 710 or not.

In other words, if no child node was found to include thecondition-to-be-added in block 710, then at block 720, rules processingdevice 120 may add the actions of the condition-to-be-added to the newchild node created at block 712, however if a child node was found toinclude the condition-to-be-added at block 710, then at block 720 rulesprocessing device 120 may add the actions of the condition-to-be-addedto the child node that was updated at block 714. In other words,according to some embodiments, the actions of a rule may be added to anode of the tree structure after the last condition of the rule isaccounted for by either determining the condition already exists in thetree structure, or by adding a new node to the tree structure thatincludes the last condition of the rule. For example, in the exemplaryembodiment shown in FIG. 3, after the “Version=1.00” and the “Lob in=(201,301,350) conditions of Rule 1 have been added to the treestructure, resulting in the creation of node 412 and node 422 shown inFIG. 4, the last condition of Rule 1, “Tier in=(‘0’,‘1’,‘2’,‘3’,‘4’,‘5’,‘6’),” is added to create node 432 and theaction associated with the rule (i.e., “minIncome=1500”) is then addedto node 432, as shown in FIG. 4. Following the addition of the actionsto the child node, method 700 may advance to block 704 to then processthe next rule of the rules file, if any.

As used in this application, the terms “component,” “module,” “system,”“server,” “processor,” “memory,” and the like are intended to includeone or more computer-related units, such as but not limited to hardware,firmware, a combination of hardware and software, software, or softwarein execution. For example, a component may be, but is not limited tobeing, a process running on a processor, an object, an executable, athread of execution, a program, and/or a computer. By way ofillustration, both an application running on a computing device and thecomputing device can be a component. One or more components can residewithin a process and/or thread of execution and a component may belocalized on one computer and/or distributed between two or morecomputers. In addition, these components can execute from variouscomputer readable media having various data structures stored thereon.The components may communicate by way of local and/or remote processessuch as in accordance with a signal having one or more data packets,such as data from one component interacting with another component in alocal system, distributed system, and/or across a network such as theInternet with other systems by way of the signal.

Certain embodiments and implementations of the disclosed technology aredescribed above with reference to block and flow diagrams of systems andmethods and/or computer program products according to exampleembodiments or implementations of the disclosed technology. It will beunderstood that one or more blocks of the block diagrams and flowdiagrams, and combinations of blocks in the block diagrams and flowdiagrams, respectively, can be implemented by computer-executableprogram instructions. Likewise, some blocks of the block diagrams andflow diagrams may not necessarily need to be performed in the orderpresented, may be repeated, or may not necessarily need to be performedat all, according to some embodiments or implementations of thedisclosed technology.

These computer-executable program instructions may be loaded onto ageneral-purpose computer, a special-purpose computer, a processor, orother programmable data processing apparatus to produce a particularmachine, such that the instructions that execute on the computer,processor, or other programmable data processing apparatus create meansfor implementing one or more functions specified in the flow diagramblock or blocks. These computer program instructions may also be storedin a computer-readable memory that can direct a computer or otherprogrammable data processing apparatus to function in a particularmanner, such that the instructions stored in the computer-readablememory produce an article of manufacture including instruction meansthat implement one or more functions specified in the flow diagram blockor blocks.

As an example, embodiments or implementations of the disclosedtechnology may provide for a computer program product, including acomputer-usable medium having a computer-readable program code orprogram instructions embodied therein, said computer-readable programcode adapted to be executed to implement one or more functions specifiedin the flow diagram block or blocks. Likewise, the computer programinstructions may be loaded onto a computer or other programmable dataprocessing apparatus to cause a series of operational elements or stepsto be performed on the computer or other programmable apparatus toproduce a computer-implemented process such that the instructions thatexecute on the computer or other programmable apparatus provide elementsor steps for implementing the functions specified in the flow diagramblock or blocks.

Accordingly, blocks of the block diagrams and flow diagrams supportcombinations of means for performing the specified functions,combinations of elements or steps for performing the specifiedfunctions, and program instruction means for performing the specifiedfunctions. It will also be understood that each block of the blockdiagrams and flow diagrams, and combinations of blocks in the blockdiagrams and flow diagrams, can be implemented by special-purpose,hardware-based computer systems that perform the specified functions,elements or steps, or combinations of special-purpose hardware andcomputer instructions.

Certain implementations of the disclosed technology are described abovewith reference to user devices may include mobile computing devices.Those skilled in the art recognize that there are several categories ofmobile devices, generally known as portable computing devices that canrun on batteries but are not usually classified as laptops. For example,mobile devices can include, but are not limited to portable computers,tablet PCs, internet tablets, PDAs, ultra-mobile PCs (UMPCs), wearabledevices, and smart phones. Additionally, implementations of thedisclosed technology can be utilized with internet of things (IoT)devices, smart televisions and media devices, appliances, automobiles,toys, and voice command devices, along with peripherals that interfacewith these devices.

In this description, numerous specific details have been set forth. Itis to be understood, however, that implementations of the disclosedtechnology may be practiced without these specific details. In otherinstances, well-known methods, structures and techniques have not beenshown in detail in order not to obscure an understanding of thisdescription. References to “one embodiment,” “an embodiment,” “someembodiments,” “example embodiment,” “various embodiments,” “oneimplementation,” “an implementation,” “example implementation,” “variousimplementations,” “some implementations,” etc., indicate that theimplementation(s) of the disclosed technology so described may include aparticular feature, structure, or characteristic, but not everyimplementation necessarily includes the particular feature, structure,or characteristic. Further, repeated use of the phrase “in oneimplementation” does not necessarily refer to the same implementation,although it may.

Throughout the specification and the claims, the following terms take atleast the meanings explicitly associated herein, unless the contextclearly dictates otherwise. The term “connected” means that onefunction, feature, structure, or characteristic is directly joined to orin communication with another function, feature, structure, orcharacteristic. The term “coupled” means that one function, feature,structure, or characteristic is directly or indirectly joined to or incommunication with another function, feature, structure, orcharacteristic. The term “or” is intended to mean an inclusive “or.”Further, the terms “a,” “an,” and “the” are intended to mean one or moreunless specified otherwise or clear from the context to be directed to asingular form. By “comprising” or “containing” or “including” is meantthat at least the named element, or method step is present in article ormethod, but does not exclude the presence of other elements or methodsteps, even if the other such elements or method steps have the samefunction as what is named.

While certain embodiments of this disclosure have been described inconnection with what is presently considered to be the most practicaland various embodiments, it is to be understood that this disclosure isnot to be limited to the disclosed embodiments, but on the contrary, isintended to cover various modifications and equivalent arrangementsincluded within the scope of the appended claims. Although specificterms are employed herein, they are used in a generic and descriptivesense only and not for purposes of limitation.

This written description uses examples to disclose certain embodimentsof the technology and also to enable any person skilled in the art topractice certain embodiments of this technology, including making andusing any apparatuses or systems and performing any incorporatedmethods. The patentable scope of certain embodiments of the technologyis defined in the claims, and may include other examples that occur tothose skilled in the art. Such other examples are intended to be withinthe scope of the claims if they have structural elements that do notdiffer from the literal language of the claims, or if they includeequivalent structural elements with insubstantial differences from theliteral language of the claims.

Exemplary Use Cases

The following exemplary use cases describe examples of a typical userflow pattern. They are intended solely for explanatory purposes and notin limitation. A company or organization (e.g., a financial serviceprovider) may generate and maintain a large volume of rules that areused to process loan applications. If all of the conditions of aparticular rule are met, then the rule may trigger various actions to betaken by the company. Since there may be large volume of rules (e.g.,millions), computing systems are often used to process the loanapplications against the rules. However, the rules may be ever changingbased on various business considerations and so it is desirable toenable company employees who are untrained in the computing programmingbe able to edit the rules without requiring them to access the code ofthe rules processing engine. Accordingly, the system (e.g., system 100)may separately maintain a rules file (e.g., via rules storage device122) from the rules processing engine (e.g., rules processing device120) that can be accessed (e.g., via employee terminal 128) and editedby employees.

For example, the rules file may be stored in cloud storage (e.g., viathird party server 126) that may be accessed by one or more employees(e.g., via employee terminal 128) via the internet. Once the employeeshave finalized a version of the rules file by updating all of the rulesas desired, the rules engine (e.g., rules processing device 120) mayreceive the rules file (e.g., via rules storage device 122) and compilethe rules into a tree structure that may be used to process an incomingloan application. Many different tree structures may be created in thisfashion and may be used in concert, with outputs of one or more treestructures feeding into one or more other trees structures as inputs. Acustomer may submit a loan application to the company (e.g., via userdevice 102) and the loan application may be sent to the rules engine forprocessing (e.g., via rules processing device 120). Upon receiving theloan application, the rules engine may input data from the loanapplication into one or more tree structures and the one or more treestructures may apply the large volumes of rules that are embodied in thetree structure(s) to the input data to generate outputs. For example, atree structure representing a set of base credit policy rules may firstdetermine if the applicant is qualified to receive a loan. If the outputof that tree structure represents that the applicant does qualify for aloan, then one or more outputs of that tree structure may be fed into asecond tree structure that may determine the APR rates for the loan. Athird three structure may then determine a set of fees or rateadjustments to the loan offer. Each tree structure may be repeatedlyused for its particular purpose once it is generated from an associatedrules file. If the rules file for any particular tree structure isupdated, then that tree structure may also be updated by rebuilding thetree structure from the updated rules fileFollowing the processing ofthe loan application using the tree structure(s), the system (e.g., viarules processing device 120) may generate a series of outputs, such as,for example, a series of requirements or features of the loan such as aminimum income, a minimum amount to be financed, a minimum down payment,an APR, fees, and the like. Some or all of these outputs may then betransmitted to an employee (e.g., via employee terminal 128) and/or tothe customer (e.g., via web server 110) for display. Some or all of theoutputs may also be stored or further processing by the system (e.g.,system 100) to generate further output data. For example, a treestructure may be used to determine an interest rate for an applicationfor a vehicle loan and the output map may include an interest rate thatis output for further processing by the system to determine, forexample, a monthly payment, dealer fees, or other such outputs that maybe determined using the outputs of the tree structure. After a loanapplication is processed by the tree structure(s), one or more outputs(e.g., maximum amount to finance, minimum amount to finance, maximumpayment, maximum warranty, minimum down payment, maximum vehicle age,maximum vehicle mileage, etc.) of the tree structure(s) may be comparedto the values of the policies offered by the company to determinewhether the application should be approved or denied.

Certain implementations of the disclosed technology are described abovewith reference to block and flow diagrams of systems and methods and/orcomputer program products according to example implementations of thedisclosed technology. It will be understood that one or more blocks ofthe block diagrams and flow diagrams, and combinations of blocks in theblock diagrams and flow diagrams, respectively, can be implemented bycomputer-executable program instructions. Likewise, some blocks of theblock diagrams and flow diagrams may not necessarily need to beperformed in the order presented, may be repeated, or may notnecessarily need to be performed at all, according to someimplementations of the disclosed technology.

These computer-executable program instructions may be loaded onto ageneral-purpose computer, a special-purpose computer, a processor, orother programmable data processing apparatus to produce a particularmachine, such that the instructions that execute on the computer,processor, or other programmable data processing apparatus create meansfor implementing one or more functions specified in the flow diagramblock or blocks. These computer program instructions may also be storedin a computer-readable memory that can direct a computer or otherprogrammable data processing apparatus to function in a particularmanner, such that the instructions stored in the computer-readablememory produce an article of manufacture including instruction meansthat implement one or more functions specified in the flow diagram blockor blocks. As an example, implementations of the disclosed technologymay provide for a computer program product, including a computer-usablemedium having a computer-readable program code or program instructionsembodied therein, said computer-readable program code adapted to beexecuted to implement one or more functions specified in the flowdiagram block or blocks. Likewise, the computer program instructions maybe loaded onto a computer or other programmable data processingapparatus to cause a series of operational elements or steps to beperformed on the computer or other programmable apparatus to produce acomputer-implemented process such that the instructions that execute onthe computer or other programmable apparatus provide elements or stepsfor implementing the functions specified in the flow diagram block orblocks.

As used herein, unless otherwise specified the use of the ordinaladjectives “first,” “second,” “third,” etc., to describe a commonobject, merely indicate that different instances of like objects arebeing referred to, and are not intended to imply that the objects sodescribed must be in a given sequence, either temporally, spatially, inranking, or in any other manner.

What is claimed is:
 1. A system for generating a data tree structure forexpediting rule-based decision-making, the system comprising: one ormore processors; and a memory in communication with the one or moreprocessors and storing instructions that, when executed by the one ormore processors, are configured to cause the system to: receive a rulesfile comprising a plurality of rules, each rule of the plurality ofrules comprising one or more conditions and one or more actions, whereineach condition is associated with a condition type; generate a pluralityof condition frequency counts, each condition frequency count (i) beingassociated with a respective unique condition type and (ii) indicating atotal number of rules having a condition associated with the respectiveunique condition type; generate, based on the plurality of rules and theplurality of condition frequency counts, the data tree structurecomprising a root node and one or more node branches, each node branchcomprising a respective first-level node and one or more respectivesecond-level nodes, each respective node of a given node branch having arespective first shared node condition, and at least some of thefirst-level nodes and second-level nodes being associated with a nodeaction; and provide the data tree structure for rule-baseddecision-making.
 2. The system of claim 1, wherein generating the datatree structure further comprises generating, for a first node branch ofthe one or more node branches based on the plurality of rules and theplurality of condition frequency counts, one or more node sub-branches,each node sub-branch comprising a second-level node of the respectiveone or more second-level nodes and respective one or more third-levelnodes, each of the one or more respective second-level nodes and the oneor more respective third-level nodes of a given node sub-branch havingthe respective first shared node condition and a respective secondshared node condition, and at least some of the second-level nodes andthird-level nodes being associated with a node action.
 3. The system ofclaim 1, wherein at least one first-level node is formed from a singlerule of the plurality of rules.
 4. The system of claim 1, wherein atleast one first-level node is formed from two or more rules of theplurality of rules.
 5. The system of claim 1, wherein the data treestructure is a hierarchy of singly linked nodes.
 6. The system of claim1, wherein the condition types comprise one or more of line-of-businessin, tier in, and version.
 7. The system of claim 1, wherein theinstructions, when executed by the one or more processors, areconfigured to further cause the system to: receive an input requestcomprising one or more input conditions; based on the one or more inputconditions, traverse each first-level node of the one or more nodebranches; determine a subset of the first-level nodes having conditionsthat are satisfied by one or more input conditions of the input request;traverse to each second-level node of the one or more node branches thatis linked to a node of the subset of the first-level nodes, bypassingeach second-level node of the one or more node branches that is notlinked to a node of the subset of the first-level nodes; and execute oneor more node actions associated with at least some of the traversednodes.
 8. The system of claim 7, wherein the instructions, when executedby the one or more processors, are configured to further cause thesystem to: identify a sub-group of traversed nodes, wherein eachtraversed node of the sub-group has a condition that is met by the oneor more input conditions of the input request; and execute the one ormore node actions associated with at least some traversed nodes of thesub-group of traversed nodes.
 9. The system of claim 8, wherein: one ormore of the node actions have a respective associated priority, and theinstructions, when executed by the one or more processors, areconfigured to further cause the system to: responsive to determiningthat two or more of the node actions associated with the sub-groupconflict with one another, prioritize execution of the two or moreconflicting node actions based on their respective associatedpriorities.
 10. The system of claim 1, wherein generating the data treestructure comprises: generating a root node; prioritizing the conditiontypes based on a magnitude of each condition type's respective frequencycount; processing a first first-rule condition of a first rule bygenerating a first child node to the root node, the first first-rulecondition having a condition type of the highest priority and the firstchild node having the first first-rule condition; processing one or morefirst-rule conditions of the first rule in order of their condition typepriority by, for each first-rule condition, creating a first-rule childnode including the first-rule condition, where the first-rule child nodeis a child node of a previously created first-rule node, and for thelast processed condition, incorporating one or more actions into thelast created first-rule child node; and processing a second rule by:responsive to determining that a first second-rule condition is notincluded in the first child node to the root node, generating a secondchild node to the root node incorporating the first second-rulecondition, wherein the first second-rule condition has a condition typeof the highest priority; and responsive to determining that the firstsecond-rule condition is included in the first child node to the rootnode and that a child node of the first child node to the root node doesnot include a second second-rule condition, creating a second-rule childnode including the second-rule condition, the second-rule child nodebeing a child of the first child node to the root node.
 11. Acomputer-implemented method for generating a data tree structure to beused for expediting rule-based decision-making, the method comprising:receiving a rules file comprising a plurality of rules, each rule of theplurality of rules comprising one or more conditions and one or moreactions, wherein each condition is associated with a condition type;generating a plurality of condition frequency counts, each conditionfrequency count (i) being associated with a respective unique conditiontype and (ii) indicating a total number of rules having a conditionassociated with the respective unique condition type; generating, basedon the plurality of rules and the plurality of condition frequencycounts, the data tree structure comprising a root node and one or morenode branches, each node branch comprising a respective first-level nodeand one or more respective second-level nodes, each of the first-levelnodes and the one or more second-level nodes of a given node branchhaving a respective first shared node condition, and at least some ofthe first-level nodes and second-level nodes being associated with anode action; and providing the data tree structure for rule-baseddecision-making.
 12. The method of claim 11, wherein generating the datatree structure comprises generating, for a first node branch of the oneor more node branches and based on the plurality of rules and theplurality of condition frequency counts, one or more node sub-branches,each node sub-branch comprising a second-level node of the respectiveone or more second-level nodes and one or more respective third-levelnodes, each of the one or more respective second-level nodes and the oneor more respective third-level nodes of a given node sub-branch havingthe respective first shared node condition and a respective secondshared node condition, and at least some of the second-level nodes andthird-level nodes being associated with a node action.
 13. The method ofclaim 11 further comprising: receiving an input request comprising oneor more input conditions; based on the input conditions, traversing eachfirst-level node of the one or more node branches; determining a subsetof the first-level nodes having conditions that are satisfied by one ormore input conditions of the input request; traversing to eachsecond-level node of the one or more node branches that is linked to anode of the subset of the first-level nodes, bypassing each second-levelnode of the one or more node branches that is not linked to a node ofthe subset of the first-level nodes; and executing one or more nodeactions associated with at least some of the traversed nodes.
 14. Themethod of claim 11 further comprising: identifying a sub-group oftraversed nodes, wherein each traversed node of the sub-group includes acondition that is met by the one or more input conditions of the inputrequest; and executing the one or more node actions associated with atleast some traversed nodes of the sub-group of traversed nodes.
 15. Themethod of claim 11, wherein at least one first-level node is formed fromone rule.
 16. The method of claim 11, wherein at least one first-levelnode is formed from two rules.
 17. A non-transitory computer-readablemedium storing instructions for generating a data tree structure to beused for expediting rule-based decision-making that, when executed byone or more processors, cause a system to: receive a rules filecomprising a plurality of rules, each rule of the plurality of rulescomprising one or more conditions and one or more actions, wherein eachcondition is associated with a condition type; generate a plurality ofcondition frequency counts, each frequency count (i) being associatedwith a respective unique condition type and (ii) indicating a totalnumber of rules having a condition associated with the respective uniquecondition type; generate, based on the plurality of rules and theplurality of condition frequency counts, the data tree structurecomprising a root node and one or more node branches, each node branchcomprising a respective first-level node and one or more respectivesecond-level nodes, each of the respective first-level nodes and the oneor more respective second-level nodes of a given node branch having arespective first shared node condition, and at least some of therespective first-level nodes and respective second-level nodes beingassociated with a node action; and provide the data tree structure forrule-based decision-making.
 18. The non-transitory computer-readablemedium of claim 17, wherein the data tree structure is a hierarchy ofsingly linked nodes.
 19. The non-transitory computer-readable medium ofclaim 17, wherein condition types comprise one or more ofline-of-business in, tier in, and version.
 20. The non-transitorycomputer-readable medium of claim 17, wherein the instructions, whenexecuted by the one or more processors, further cause the system to:receive an input request comprising one or more input conditions; basedon the one or more input conditions, traverse each first-level node ofthe one or more node branches; determine a subset of the first-levelnodes having conditions that are satisfied by one or more inputconditions of the input request; traverse to each second-level node ofthe one or more node branches that is linked to a node of the subset ofthe first-level nodes, bypassing each second-level node of the one ormore node branches that is not linked to a node of the subset of thefirst-level nodes; and execute one or more node actions associated withat least some of the traversed nodes.